babl: remove unused static linear luts for u8 rgb space converters

diff --git a/babl/babl-fish-path.c b/babl/babl-fish-path.c
index 298d36a53613803ae1c2b8b69a4f4d7610bce9e5..b7133afc6355fbc7a4e241713805b3d51f0fb794 100644 (file)
--- a/babl/babl-fish-path.c
+++ b/babl/babl-fish-path.c
@@ -221,18 +221,13 @@ get_conversion_path (PathContext *pc,
           fpi.destination = pc->to_format;
 
           get_path_instrumentation (&fpi, pc->current_path, &path_cost, &ref_cost, &path_error);
-          //path_cost += pc->current_path->count * 1000; // punish long chains
           if(debug_conversions && current_length == 1)
             fprintf (stderr, "%s  error:%f cost:%f  \n",
-                 babl_get_name (pc->current_path->items[0]),
-                 /*babl_get_name (pc->fish_path->fish.source),
-                 babl_get_name (pc->fish_path->fish.destination),*/
-                 path_error,
-                 path_cost /*, current_length*/);
+                 babl_get_name (pc->current_path->items[0]), path_error, path_cost);
 
           if ((path_cost < ref_cost) && /* do not use paths that took longer to compute than reference */
-              (path_cost < pc->fish_path->fish_path.cost) &&
-              (path_error <= legal_error )
+              (path_cost < pc->fish_path->fish_path.cost) && // best thus far
+              (path_error <= legal_error )               // within tolerance
               )
             {
               /* We have found the best path so far,

diff --git a/babl/babl-matrix.h b/babl/babl-matrix.h
index d4e29d9654a92f65c62514b5e19098e7edaa9940..8f331a524d9d0c9a551fa8c2f06120c5d4801e50 100644 (file)
--- a/babl/babl-matrix.h
+++ b/babl/babl-matrix.h
@@ -97,16 +97,16 @@ static inline void babl_matrix_mul_vectorf (const double *mat, const float *v_in
 
 static inline void babl_matrix_mul_vectorff (const float *mat, const float *v_in, float *v_out)
 {
-  float a = v_in[0], b = v_in[1], c = v_in[2];
-  float m_0_0 = m(mat, 0, 0);
-  float m_0_1 = m(mat, 0, 1);
-  float m_0_2 = m(mat, 0, 2);
-  float m_1_0 = m(mat, 1, 0);
-  float m_1_1 = m(mat, 1, 1);
-  float m_1_2 = m(mat, 1, 2);
-  float m_2_0 = m(mat, 2, 0);
-  float m_2_1 = m(mat, 2, 1);
-  float m_2_2 = m(mat, 2, 2);
+  const float a = v_in[0], b = v_in[1], c = v_in[2];
+  const float m_0_0 = m(mat, 0, 0);
+  const float m_0_1 = m(mat, 0, 1);
+  const float m_0_2 = m(mat, 0, 2);
+  const float m_1_0 = m(mat, 1, 0);
+  const float m_1_1 = m(mat, 1, 1);
+  const float m_1_2 = m(mat, 1, 2);
+  const float m_2_0 = m(mat, 2, 0);
+  const float m_2_1 = m(mat, 2, 1);
+  const float m_2_2 = m(mat, 2, 2);
 
   v_out[0] = m_0_0 * a + m_0_1 * b + m_0_2 * c;
   v_out[1] = m_1_0 * a + m_1_1 * b + m_1_2 * c;
@@ -117,18 +117,18 @@ static inline void babl_matrix_mul_vectorff_buf3 (const float *mat, const float
                                                   int samples)
 {
   int i;
-  float m_0_0 = m(mat, 0, 0);
-  float m_0_1 = m(mat, 0, 1);
-  float m_0_2 = m(mat, 0, 2);
-  float m_1_0 = m(mat, 1, 0);
-  float m_1_1 = m(mat, 1, 1);
-  float m_1_2 = m(mat, 1, 2);
-  float m_2_0 = m(mat, 2, 0);
-  float m_2_1 = m(mat, 2, 1);
-  float m_2_2 = m(mat, 2, 2);
+  const float m_0_0 = m(mat, 0, 0);
+  const float m_0_1 = m(mat, 0, 1);
+  const float m_0_2 = m(mat, 0, 2);
+  const float m_1_0 = m(mat, 1, 0);
+  const float m_1_1 = m(mat, 1, 1);
+  const float m_1_2 = m(mat, 1, 2);
+  const float m_2_0 = m(mat, 2, 0);
+  const float m_2_1 = m(mat, 2, 1);
+  const float m_2_2 = m(mat, 2, 2);
   for (i = 0; i < samples; i ++)
   {
-    float a = v_in[0], b = v_in[1], c = v_in[2];
+    const float a = v_in[0], b = v_in[1], c = v_in[2];
 
     v_out[0] = m_0_0 * a + m_0_1 * b + m_0_2 * c;
     v_out[1] = m_1_0 * a + m_1_1 * b + m_1_2 * c;
@@ -141,16 +141,16 @@ static inline void babl_matrix_mul_vectorff_buf3 (const float *mat, const float
 static inline void babl_matrix_mul_vectorff_buf4 (const float *mat, const float *v_in, float *v_out,
                                                   int samples)
 {
+  const float m_0_0 = m(mat, 0, 0);
+  const float m_0_1 = m(mat, 0, 1);
+  const float m_0_2 = m(mat, 0, 2);
+  const float m_1_0 = m(mat, 1, 0);
+  const float m_1_1 = m(mat, 1, 1);
+  const float m_1_2 = m(mat, 1, 2);
+  const float m_2_0 = m(mat, 2, 0);
+  const float m_2_1 = m(mat, 2, 1);
+  const float m_2_2 = m(mat, 2, 2);
   int i;
-  float m_0_0 = m(mat, 0, 0);
-  float m_0_1 = m(mat, 0, 1);
-  float m_0_2 = m(mat, 0, 2);
-  float m_1_0 = m(mat, 1, 0);
-  float m_1_1 = m(mat, 1, 1);
-  float m_1_2 = m(mat, 1, 2);
-  float m_2_0 = m(mat, 2, 0);
-  float m_2_1 = m(mat, 2, 1);
-  float m_2_2 = m(mat, 2, 2);
   for (i = 0; i < samples; i ++)
   {
     float a = v_in[0], b = v_in[1], c = v_in[2];
@@ -168,18 +168,18 @@ static inline void babl_matrix_mul_vector_buf4 (const double *mat, const double
                                                 int samples)
 {
   int i;
-  double m_0_0 = m(mat, 0, 0);
-  double m_0_1 = m(mat, 0, 1);
-  double m_0_2 = m(mat, 0, 2);
-  double m_1_0 = m(mat, 1, 0);
-  double m_1_1 = m(mat, 1, 1);
-  double m_1_2 = m(mat, 1, 2);
-  double m_2_0 = m(mat, 2, 0);
-  double m_2_1 = m(mat, 2, 1);
-  double m_2_2 = m(mat, 2, 2);
+  const double m_0_0 = m(mat, 0, 0);
+  const double m_0_1 = m(mat, 0, 1);
+  const double m_0_2 = m(mat, 0, 2);
+  const double m_1_0 = m(mat, 1, 0);
+  const double m_1_1 = m(mat, 1, 1);
+  const double m_1_2 = m(mat, 1, 2);
+  const double m_2_0 = m(mat, 2, 0);
+  const double m_2_1 = m(mat, 2, 1);
+  const double m_2_2 = m(mat, 2, 2);
   for (i = 0; i < samples; i ++)
   {
-    double a = v_in[0], b = v_in[1], c = v_in[2];
+    const double a = v_in[0], b = v_in[1], c = v_in[2];
 
     v_out[0] = m_0_0 * a + m_0_1 * b + m_0_2 * c;
     v_out[1] = m_1_0 * a + m_1_1 * b + m_1_2 * c;

diff --git a/babl/babl-space.c b/babl/babl-space.c
index df3dde97939d539cda3ca5a45039b1eef772761e..40a21c94e7a04f15c943c275dbc0f60385ce6d22 100644 (file)
--- a/babl/babl-space.c
+++ b/babl/babl-space.c
@@ -583,13 +583,6 @@ universal_nonlinear_rgb_u8_converter (const Babl *conversion,unsigned char *src_
   uint8_t *rgb_out_u8 = (void*)dst_char;
 
   float *rgba_out = babl_malloc (sizeof(float) * 4 * samples);
-  static float linear_lut_u8[258]={-1.0,};
-
-  if (linear_lut_u8[0] < 0)
-  {
-    for (i = 0; i < 256; i++)
-      linear_lut_u8[i] = i / 255.0;
-  }
 
   for (i = 0; i < samples; i++)
   {
@@ -689,13 +682,6 @@ universal_nonlinear_rgba_u8_converter_sse2 (const Babl *conversion,unsigned char
   uint8_t *rgba_out_u8 = (void*)dst_char;
 
   float *rgba_out = babl_malloc (sizeof(float) * 4 * samples);
-  static float linear_lut_u8[258]={-1.0,};
-
-  if (linear_lut_u8[0] < 0)
-  {
-    for (i = 0; i < 256; i++)
-      linear_lut_u8[i] = i / 255.0;
-  }
 
   for (i = 0; i < samples * 4; i+= 4)
   {
@@ -733,13 +719,6 @@ universal_nonlinear_rgb_u8_converter_sse2 (const Babl *conversion,unsigned char
   uint8_t *rgb_out_u8 = (void*)dst_char;
 
   float *rgba_out = babl_malloc (sizeof(float) * 4 * samples);
-  static float linear_lut_u8[258]={-1.0,};
-
-  if (linear_lut_u8[0] < 0)
-  {
-    for (i = 0; i < 256; i++)
-      linear_lut_u8[i] = i / 255.0;
-  }
 
   for (i = 0; i < samples; i++)
   {
@@ -827,7 +806,7 @@ add_rgb_adapter (Babl *babl,
                        "linear", universal_nonlinear_rgb_u8_converter_sse2,
                        NULL));
     }
-    else
+    //else
 #endif
     {
        prep_conversion(babl_conversion_new(babl_format_with_space("RGBA float", space),

diff --git a/babl/babl-trc.c b/babl/babl-trc.c
index d0821cdcf9e2f3ad41e20ea2e8dd2b9d2549f504..46bb98ea6ca27eaa78a9748bc9f468cfe33d7e98 100644 (file)
--- a/babl/babl-trc.c
+++ b/babl/babl-trc.c
@@ -38,10 +38,14 @@ static inline float babl_trc_lut_from_linear (const Babl *trc_, float x)
   entry = x * (trc->lut_size-1);
   diff =  ( (x * (trc->lut_size-1)) - entry);
 
-  if (entry >= trc->lut_size) entry = trc->lut_size - 1;
+  if (entry >= trc->lut_size -1)
+  {
+    entry = trc->lut_size - 1;
+    diff = 0.0;
+  }
   else if (entry < 0) entry = 0;
 
-  if (diff > 0.0 && entry < trc->lut_size-1)
+  if (diff > 0.0)
   {
     ret = trc->inv_lut[entry] * (1.0 - diff) + trc->inv_lut[entry+1] * diff;
   }

diff --git a/tools/babl-benchmark.c b/tools/babl-benchmark.c
index 538ddc34fe14c48ea09324bd612edc2af3102a1f..1f1f90c522e2f487e4bd6959273cc79a4a2ad647 100644 (file)
--- a/tools/babl-benchmark.c
+++ b/tools/babl-benchmark.c
@@ -75,20 +75,18 @@ test (void)
      babl_format("R'G'B'A u8"),
      babl_format("Y float"),
      babl_format("R'G'B'A u16"),
-     babl_format_with_space("R'G'B'A u8",     babl_space("ProPhoto")),
      babl_format_with_space("RGBA float",     babl_space("ProPhoto")),
      babl_format_with_space("R'G'B' u16",     babl_space("ProPhoto")),
 #endif
-     babl_format("CIE Lab float"),
-     babl_format("RGBA float"),
-     babl_format("R'G'B'A float"),
-     babl_format("Y float"),
-     babl_format("R'G'B'A u8"),
-     babl_format_with_space("RGBA float",    babl_space("ProPhoto")),
-     babl_format_with_space("R'G'B'A float", babl_space("ProPhoto")),
-     babl_format_with_space("Y float",       babl_space("ProPhoto")),
-     babl_format_with_space("R'G'B'A u8",     babl_space("Adobe")),
-     babl_format_with_space("R'G'B'A u8",     babl_space("ProPhoto")),
+     //babl_format("R'G'B'A u8"),
+     //babl_format("R'G'B'A u16"),
+       babl_format_with_space("R'G'B'A u8", babl_space("ProPhoto")),
+       babl_format_with_space("R'G'B'A half", babl_space("ProPhoto")),
+       babl_format_with_space("R'G'B'A float", babl_space("ProPhoto")),
+       babl_format_with_space("R'G'B'A double", babl_space("ProPhoto")),
+       babl_format_with_space("cairo-RGB24", babl_space("Adobe")),
+       babl_format_with_space("cairo-ARGB32", babl_space("Adobe")),
+
      };
   int n_formats = sizeof (formats) / sizeof (formats[0]);
   const Babl *fishes[50 * 50];